{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "593b93fd-65ab-42f7-9bd3-b0e31d6a64fa",
   "metadata": {
    "tags": []
   },
   "source": [
    "## movie简介\n",
    "MoviePy是一个用于视频编辑的python模块，你可以用它实现一些基本的操作(比如视频剪辑，视频拼接，插入标题),还可以实现视频合成，还有视频处理，抑或用它加入一些自定义的高级的特效。总之，它的功能还是蛮丰富的。此外，MoviePy可以读写绝大多数常见的视频格式，甚至包括GIF格式！是不是很兴奋呢？基于Python2.7以上的版本，MoviePy可以轻松实现跨平台，Mac/Windows/Linux统统没问题，这也以意味着，MoviePy项目可以部署到服务端，在服务端进行视频处理。\n",
    "\n",
    "原文链接：https://blog.csdn.net/ucsheep/article/details/80999939\n",
    "英文文档：https://zulko.github.io/moviepy/index.html（最全）\n",
    "中文文档：http://doc.moviepy.com.cn/index.html\n",
    "## 安装\n",
    "- moviepy本体安装很简单\n",
    "```sh\n",
    "pip3 install moviepy\n",
    "```\n",
    "- FFMPEG\n",
    "MoviePy的视频读写依赖于我们大名鼎鼎的FFMPEG这个软件，你也无需担心，如果你之前没有安装过的话，FFMPEG应该在ImageIO安装的时候就被自动下载和安装了,一般自己安装会高于这个版本，所以会报错，我们可以参考源码文件moviepy/config_defaults.py修改FFMPEG_BINARY属性，进而使用自定义的版本，如果，害怕出错，让程序帮助你自动安装会是一个不错的选择。\n",
    "MoviePy安装会安装ImageIO包，而FFMPEG的位置在`site-packages\\imageio_ffmpeg\\binaries`\n",
    "比如我的在\n",
    "`D:\\python\\virtualenvs_win\\ai\\Lib\\site-packages\\imageio_ffmpeg\\binaries`\n",
    "你执行程序的时候程序会自动导入ImageIO包安装的FFMPEG，你无需担心，当然也可以在moviepy包的`moviepy/config_defaults.py`配置自己安装的路径\n",
    "p.s. linux会自动查找ffmpeg程序\n",
    "\n",
    "- IMAGEMAGICK\n",
    "IMAGEMAGICK不是必需的，除非你想要把文本写入视频中，除了win系统，IMAGEMAGICK在你安装之后会自动检测，win需要你把IMAGEMAGICK写入环境变量里。\n",
    "下载地址：https://www.imagemagick.org/script/index.php\n",
    "win版百度盘：链接：https://pan.baidu.com/s/1Da7XwGWlOVPaB7OBI949lQ 提取码：xy5e\n",
    "p.s. linux如果安装好了imagemagick，即convert命令，会自动检测，不需要配置\n",
    "```python\n",
    "# 嫌麻烦的可以在代码开头导入moviepy包之前写上\n",
    "import os\n",
    "os.environ[\"IMAGEMAGICK_BINARY\"] = \"D:\\\\software\\\\ImageMagick-7.1.0-Q16-HDRI\\\\magick.exe\"\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6ecfc304",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "video_path = \"dde-introduction.mp4\"\n",
    "%matplotlib inline\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.animation as animation\n",
    "from IPython.display import HTML,display,Image\n",
    "from moviepy.video.compositing.CompositeVideoClip import clips_array\n",
    "\n",
    "def f_show(frame):\n",
    "    plt.axis(\"off\")\n",
    "    plt.imshow(frame)\n",
    "    plt.show()\n",
    "\n",
    "def clips_show(clips, t=15):\n",
    "    f_show(clips_array([clips]).get_frame(t))\n",
    "\n",
    "def pre_show_clip(clip):\n",
    "    plt.subplot(221), plt.imshow(clip.get_frame(5)), plt.axis(\"off\")\n",
    "    plt.subplot(222), plt.imshow(clip.get_frame(15)), plt.axis(\"off\")\n",
    "    plt.subplot(223), plt.imshow(clip.get_frame(30)), plt.axis(\"off\")\n",
    "    plt.subplot(224), plt.imshow(clip.get_frame(45)), plt.axis(\"off\")\n",
    "    plt.show()\n",
    "\n",
    "def display_video(clip, jump=5):\n",
    "    t = 0\n",
    "    frame_lists = []\n",
    "    fig = plt.figure()\n",
    "\n",
    "    while t < clip.end:\n",
    "        frame = clip.get_frame(t)\n",
    "        plt.axis(\"off\")\n",
    "        frame_lists.append([plt.imshow(frame)])\n",
    "        t += jump\n",
    "\n",
    "\n",
    "    # interval:每一帧显示多久  repeat_delay：全部播放完毕后多久重放\n",
    "    ani = animation.ArtistAnimation(fig, frame_lists, interval=500, blit=True, repeat_delay=1000)\n",
    "    # ani.save(\"movie.mp4\")\n",
    "    display(HTML(ani.to_html5_video()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d553683b",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from moviepy.editor import VideoFileClip\n",
    "\n",
    "video_clip = VideoFileClip(video_path)\n",
    "# display_video(video_clip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0fec8933",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Clip.get_frame\n",
    "# 获取剪辑指定时间的frame\n",
    "frame0 = video_clip.get_frame(5)\n",
    "f_show(frame0)\n",
    "# pre_show_clip(video_clip)\n",
    "# 保存t时间图片\n",
    "# video_clip.save_frame(\"test_frame1.png\", t=500)\n",
    "# Image(\"test_frame1.png\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "096905eb",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 剪辑用函数\n",
    "# Clip.cutout\n",
    "# 基于fl_time方法，删除剪辑的ta~tb时间段的视频，返回新的剪辑\n",
    "cut_video = video_clip.cutout(ta=0, tb=10)\n",
    "f_show(cut_video.get_frame(0))\n",
    "\n",
    "# Clip.subclip\n",
    "# 基于fl_time方法，返回剪辑的t_start~t_end时间段的剪辑（可以传负数，会从结尾开始算）\n",
    "cut_video = video_clip.subclip(t_start=5, t_end=150)\n",
    "f_show(cut_video.get_frame(0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ee8598a6",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Clip.fl_time\n",
    "# 通过观察Clip.cutout的源码,得知fl_time方法根据传的fl函数（返回有效t）对剪辑进行剪切\n",
    "ta=0\n",
    "tb=10\n",
    "# fl函数应该返回需要保留的时间\n",
    "fl_time_func = lambda t: t + (t >= ta)*(tb - ta)\n",
    "# apply_to指定mask或audio也会同时被剪切\n",
    "# 此fl逻辑：当t小于ta时直接返回，当t>=ta时返回t+(tb-ta),完美去除ta~tb时间段的t\n",
    "cut_video = video_clip.fl_time(fl_time_func)\n",
    "f_show(cut_video.get_frame(0))\n",
    "\n",
    "# Clip.fl\n",
    "# 对剪辑进行剪切,fl_time使用其达到剪切的功能，其传的函数（fun）和fl_time有所不同\n",
    "# fun函数：需要返回对应时间的frame,内部基于get_frame（gf）实现，我们只需要对t进行处理，也就是fl_time_func做的\n",
    "fl_fun = lambda gf, t: gf(fl_time_func(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d15cab29",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 其他较重要的Clip的方法\n",
    "- Clip.set_start(t, change_end=True)\n",
    "修改剪辑的开始时间为t\n",
    "change_end=True时会尝试给剪辑延长t时间，即总时长不变，否则总时长会尝试变成原时长-t\n",
    "\n",
    "- Clip.set_end(t)\n",
    "设置剪辑的结束时间用\n",
    "\n",
    "- Clip.set_duration(t, change_end=True)\n",
    "设置剪辑的持续时长，根据是持续时长t会自动设置开始时间或结束时间(change_end=True决定改变end还是start)\n",
    "\n",
    "- Clip.is_playing\n",
    "判断t是否可播放的（在start~end之间），如果t是numpy array类型，对应返回矢量列表\n",
    "\n",
    "- Clip.iter_frames(fps=None, with_times = False, logger=None,dtype=None)\n",
    "该方法返回剪辑的可迭代frame，取frame（帧）规则是每1/fps,取一帧"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e00bbddd",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# VideoClip.save_frame(filename, t=0, withmask=True)\n",
    "# 保存对应时间的frame为文件,withmask可以带上蒙版\n",
    "video_clip.save_frame(\"test_ims/save_frame.png\", t=150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "aeb63336",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Writing frames test_ims/frame%03d.png.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                          "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done writing frames test_ims/frame%03d.png.\n",
      "['test_ims/frame000.png', 'test_ims/frame001.png', 'test_ims/frame002.png', 'test_ims/frame003.png', 'test_ims/frame004.png', 'test_ims/frame005.png', 'test_ims/frame006.png']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "# VideoClip.write_images_sequence\n",
    "# 基于save_frame实现的，根据fps截取视频图片的的方法\n",
    "# fps代表每秒保存frame的数量。fps=0.1 代表保存clip.duration * fps + 1 张图片(1 min的视频即60s, 保存60*0.1+1张)\n",
    "file_names = video_clip.write_images_sequence(nameformat=\"test_ims/frame%03d.png\", fps=0.1)\n",
    "print(file_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e744707",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# VideoClip.write_gif\n",
    "参数说明如下：\n",
    "- program：用于转换的软件，可以是“imageio”（这将通过imageio使用FreeImage库），或者是“ImageMagick”，或者是“ffmpeg”\n",
    "- opt：应用优化的选项，如果program参数是’imageio’，opt必须是’wu’（Wu）或“nq”（Neuquant），。如果program=‘ImageMagick’，opt可以是“optimizeplus”或“OptimizeTransparency”\n",
    "- fuzz：仅当program='ImageMagick’时需要，通过考虑小于fuzz%的颜色差异实际上是相同的来压缩GIF文件大小\n",
    "- loop：表示GIF文件播放时循环播放多少次，如果为0就一直不停地播放，否则播放设定次数后就停止，该参数由GIF文件头控制\n",
    "- dispose：表示播放动画时渲染当前帧时，如何处理前一帧，该参数由GIF文件头控制，moviepy没有说明该参数怎么使用，缺省值为False，老猿查阅了相关资料，才基本确认该参数的作用，但GIF中该控制参数有四个取值，不知道是否都支持，取值及含义如下：\n",
    "    - 为0表示绘制一个完整大小的、不透明的GIF帧来替换上一帧，就算连续的两帧只在局部上有细微的差异，每一帧依然是完整独立的绘制\n",
    "    - 为1表示未被当前帧覆盖的前一帧像素将继续显示，这种方式常用于对GIF动画进行优化，当前帧只需在上一帧的基础上做局部刷新，上一帧中没有被当前帧覆盖的像素区域将继续展示。这种方式既能节省内存，也能提高解码速度\n",
    "    - 为2 表示绘制当前帧之前，会先把前一帧的绘制区域恢复成背景色，这种方式常用于优化很多帧背景相同的情况，上一帧的背景色能通过当前帧的透明区域显示\n",
    "    - 为3表示绘制当前帧时，会先恢复到最近一个设置为False或1的帧，然后再将当前帧叠加到上面，这种方式性能比较差，已经被慢慢废弃\n",
    "- colors：关于这个参数moviepy没有说明，老猿将该值设置为一个比较大的值，结果报错“ValueError: GIF quantize param must be 2…256”，最后查阅资料确认该参数表示色彩量化使用的调色板索引，取值为2到256。GIF最高支持8位256色，那么如果原图是真彩色的，则在生成最终效果图时，就涉及到真彩色到256的降色。真彩色是24位的，有2的24种颜色，每个像素用3个字节标识一个颜色，R、G、B各占一个字节，而256色每个像素只用一个字节从调色板中索引一种颜色，调色板最多有256种颜色。将2^24种颜色降为256种颜色，降色的过程被成为色彩量化。色彩量化过程分两步：1、根据图片定制调色板；2、遍历像素，对于每一个像素，从调色板中找最接近的颜色，记录该颜色索引。关于调色板请参考《调色板详解》\n",
    "- tempfiles：将每个帧写入一个文件，而不是将它们传递到RAM中。在内存很少的计算机上很有用，只能与ImageMagick或ffmpeg一起使用。\n",
    "原文链接：https://blog.csdn.net/LaoYuanPython/article/details/106678677"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "23983c38",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MoviePy - Building file test_gif/test1.gif\n",
      "\n",
      "MoviePy - - Generating GIF frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                            \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MoviePy - - Optimizing GIF with ImageMagick...\n",
      "Moviepy - Running:\n",
      ">>> \"+ \" \".join(cmd)\n",
      "Moviepy - Command successful\n",
      "MoviePy - GIF ready: test_gif/test1.gif.\n"
     ]
    }
   ],
   "source": [
    "# VideoClip.write_gif\n",
    "# 输出gif文件\n",
    "# p.s 未知原因program=\"ImageMagick\"时，tempfiles=True才能正常生成文件，猜测可能和ImageMagick版本有关？或者moviepy代码问题\n",
    "video_clip.subclip(30,35)\\\n",
    "    .write_gif(\"test_gif/test1.gif\",\n",
    "                fps=5,\n",
    "                program=\"ImageMagick\",\n",
    "                dispose=True,\n",
    "                tempfiles=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "33e0ac54",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# VideoClip.add_mask\n",
    "# add_mask方法就是给剪辑增加遮罩，遮罩的duration是调用者的duration，遮罩是由完全不透明（全1组成的YUV值）的像素构成\n",
    "new_video_clip = video_clip.add_mask()\n",
    "# new_video_clip.save_frame(\"test_ims/add_mask.png\", t=30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3ab4cb78",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<AxesSubplot:>,\n",
       " <matplotlib.image.AxesImage at 0x7f42e85429b0>,\n",
       " (-0.5, 1919.5, 1919.5, -0.5))"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# VideoClip.on_color\n",
    "# 对clip混合ColorClip(有col_opacity不透明度时)或添加背景颜色\n",
    "# on_color方法用于将当前剪辑放置到一个指定颜色背景的可能更大的剪辑上，用于在原始剪辑扩展大小时将空白处设置为指定颜色。返回值为处理后的新剪辑。\n",
    "new_video_clip = video_clip.on_color((2980, 1920), (255,0,0), col_opacity=0.2, pos=(2980-1920, (1920-1024)/2))\n",
    "new_video_clip1 = video_clip.on_color((1920, 1920), (255,0,0))\n",
    "plt.subplot(121), plt.imshow(new_video_clip.get_frame(15)), plt.axis(\"off\")\n",
    "plt.subplot(122), plt.imshow(new_video_clip1.get_frame(15)), plt.axis(\"off\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8c2b612",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# VideoClip.to_ImageClip方法\n",
    "# to_ImageClip方法将剪辑对应时刻t的帧转换成ImageClip图像剪辑，图像剪辑是所有帧都是固定图像数据的剪辑，所有帧都对应为图像数据。\n",
    "\n",
    "# 调用语法：\n",
    "# to_ImageClip(self, t=0, with_mask=True, duration=None)\n",
    "\n",
    "# 说明：\n",
    "# 参数非常简单，不单独解释，但注意图像剪辑在输出到文件时需要设置duration和fps值（为1即可），同时可能在输出文时要指定codec类型，否则可能播放失败。\n",
    "\n",
    "image_clip = video_clip.to_ImageClip(t=30,duration=1)\n",
    "image_clip.write_videofile(\"test_video/im_clip.mp4\", fps=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d53bb21b",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# VideoClip.to_mask\n",
    "# to_mask方法返回一个由调用者剪辑实例构建的遮罩剪辑。\n",
    "\n",
    "# 说明：\n",
    "# to_mask方法用于将当前剪辑生成一个遮罩剪辑，处理时如果调用对象本身有遮罩，则直接返回调用剪辑的遮罩，否则根据调用剪辑的数据生成遮罩数据，生成时是将调用剪辑的每一帧数据的具体像素的YUV值中的某个除以255来实现遮罩的效果，具体对YUV哪个数据进行处理由参数canal指定，0代码Y值、1代表U值、2代表V值。\n",
    "newclip = video_clip.to_mask(0)\n",
    "pre_show_clip(newclip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "e08c7d49",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# VideoClip.to_RGB\n",
    "# 返回一个由遮罩剪辑生成的非遮罩剪辑。\n",
    "\n",
    "# 说明：\n",
    "# 该方法的处理过程是，如果调用剪辑不是遮罩，则直接返回自身，否则将剪辑的帧像素YUV各乘以255，再将每个像素的YUV三元组变成一个九元组，其元素是YUV值重复3遍。\n",
    "\n",
    "# 这样变换的原因老猿并不十分清楚，查阅了一些资料，估计是因为YUV到RGB并不是简单YUV到RGB的一个转换，而是到24位真彩色的转换，因为一般来说直接采集到的视频数据是RGB24的格式，其位数是YUV的三倍，当RGB24变为YUV时其实是进行了降色处理，现在要恢复到RGB24因此需要进行乘以3。\n",
    "\n",
    "# 但这里有些原理没说清楚，比如RGB24是用三个字节来表示颜色，YUV在这里也用了三个字节，RGB为什么变成了9个字节？这个问题一时无解，先留着。\n",
    "\n",
    "# 另外这个方法在moviepy中只是对遮罩进行处理，当带遮罩的剪辑输出到文件或将剪辑的帧保存到图像或gif文件时会调用该方法对剪辑的遮罩进行处理。\n",
    "f_show(video_clip.get_frame(15)) # 原剪辑\n",
    "newclip = video_clip.to_mask(0) # 原剪辑变成遮罩\n",
    "f_show(newclip.get_frame(15))\n",
    "# pre_show_clip(newclip)\n",
    "newclip = newclip.to_RGB()      # 遮罩变RGB\n",
    "f_show(newclip.get_frame(15))\n",
    "# pre_show_clip(newclip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25a9fc23",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# VideoClip.write_videofile\n",
    "# 输出视频文件\n",
    "# codec编码器，如果filename有后缀（'.mp4', '.ogv', '.webm'），则默认会自行匹配\n",
    "# audio 音频设置（``True``, ``False``, or a file name.）\n",
    "# audio_codec 音频编码Default is 'libmp3lame'\n",
    "# audio_bitrate音频比特率，决定输出文件的音频质量和大小\n",
    "# preset 决定FFMPEG的优化压缩的速度\n",
    "# threads FFMPEG的使用线程数量，在多核计算机上可以提升视频写入速度\n",
    "# ffmpeg_params 你需要的ffmpeg的其他参数\n",
    "# logger 默认为进程条日志记录"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc7683b4",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 其他重要的\n",
    "- VideoClip.subfx(fx, ta=0, tb=None, **kwargs)\n",
    "对clip的ta~tb时间段使用fx方法（from moviepy.video.fx import volumex, resize, mirrorx）\n",
    "- VideoClip.fl_image\n",
    "该方法传入一个函数（image_func）对frame进行数字化处理\n",
    "    - image_func：参数image_func是对剪辑帧进行图像变换的函数，带一个参数，参数就是要处理的帧，这个帧直接通过get_frame去获取，image_func函数的返回值为经过变换后的帧\n",
    "    - apply_to：apply_to表示变换是否需要同时作用于剪辑的音频和遮罩，其值可以为’mask’、‘audio’、[‘mask’,‘audio’]\n",
    "- afx(self, fun, *a, **k)\n",
    "afx方法对原剪辑浅拷贝后的拷贝剪辑的声音进行变换，返回新剪辑。\n",
    "说明：\n",
    " 声音变换由函数fun进行\n",
    " a和k是fun变换函数需要带的可变参数和关键字参数\n",
    " afx实际上是调用父类Clip的fx方法去执行fun函数的\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "81695646",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from moviepy.editor import ColorClip\n",
    "# print(video_clip.size)\n",
    "mask = ColorClip((1920, 1080), (255,255,0), ismask=True, duration=video_clip.duration)\n",
    "mask_0_0 = ColorClip((1920, 1080), 0.0, ismask=True, duration=video_clip.duration)\n",
    "mask_1_0 = ColorClip((1920, 1080), 1.0, ismask=True, duration=video_clip.duration)\n",
    "new_video_clip = video_clip.set_mask(mask)\n",
    "new_video_clip.save_frame(\"test_ims/set_mask.png\", t=30)\n",
    "new_video_clip_0_0 = video_clip.set_mask(mask_0_0)\n",
    "new_video_clip_0_0.save_frame(\"test_ims/set_mask_0_0.png\", t=30)\n",
    "new_video_clip_1_0 = video_clip.set_mask(mask_1_0)\n",
    "new_video_clip_1_0.save_frame(\"test_ims/set_mask_1_0.png\", t=30)\n",
    "# Image(\"test_ims/set_mask.png\")\n",
    "# Image(\"test_ims/set_mask_0_0.png\")    # 透明了\n",
    "# Image(\"test_ims/set_mask_1_0.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46dbeac5",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# CompositeVideoClip合成视频剪辑\n",
    "CompositeVideoClip是一种由其他视频剪辑组合构成一起播放的视频剪辑，这是大多数合成剪辑的基类。concatenate_videoclips在method参数设置为’compose’时，实际上就是调用的CompositeVideoClip完成合成的。\n",
    "\n",
    "构造方法\n",
    "__init__(self, clips, size=None, bg_color=None, use_bgclip=False,ismask=False)\n",
    "\n",
    "参数说明：\n",
    "- clips：多个视频剪辑的列表，列表中的每个元素都是VideoClip类型的对象。列表中的每个剪辑都将显示在列表中其后面出现的剪辑的下面。每个剪辑的pos属性决定剪辑放置在最终合成剪辑屏幕的位置，每个剪辑的mask遮罩属性决定每个剪辑哪部分可见哪部分不可见\n",
    "- size：最终剪辑的大小（分辨率），如果size为None，则将clips中第一个剪辑的size作为最终剪辑的size\n",
    "- bg_color：设置合成剪辑的背景色，背景色用于剪辑未填充且无遮罩的区域，如果要一个透明剪辑，则设置为None，否则为一个代表RGB颜色的三元组,如(0,0,0)代表黑色，也即透明色。该参数只有use_bgclip为False的情况下使用，实际上是通过构建一个由bg_color指定颜色的ColorClip来实现的\n",
    "- use_bgclip：如果列表中的第一个剪辑应用作所有其他剪辑的“背景”，则设置为True。第一个剪辑的大小必须与最后合成剪辑的大小相同。如果没有透明度，则最终剪辑将没有遮罩\n",
    "- ismask：最终合成剪辑是否为遮罩剪辑。\n",
    "## clips属性\n",
    "clips属性保存合成剪辑所需要的所有剪辑的列表，但不包含背景剪辑，即如果use_bgclip为True，则clips保存的为构造方法clips参数对应列表第二个及之后的所有剪辑，如果use_bgclip为False，则就是构造方法clips参数对应的列表。\n",
    "\n",
    "## playing_clips方法\n",
    "playing_clips方法用于判断clips属性中对应剪辑在参数指定的t时刻是否处于播放状态，对处于播放状态的剪辑存放到一个列表中返回。\n",
    "\n",
    "调用语法：playing_clips(self, t=0)\n",
    "\n",
    "## close方法\n",
    "用于关闭音频及由CompositeVideoClip创建的背景剪辑，其他资源的释放不处理。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94778668",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## ImageSequenceClip图像序列剪辑\n",
    "\n",
    "之前介绍过VideoClip.write_images_sequence方法，write_images_sequence方法用于将剪辑输出到一系列图像文件中，而ImageSequenceClip则基本上与write_images_sequence过程可逆，用于将一系列图像生成剪辑。\n",
    "\n",
    "参数说明：\n",
    "- sequence：参数sequence可以是如下三种之一\n",
    "    - 一个仅包含图片的文件夹路径目录名，目录下的文件将按字母顺序排列作为处理的系列图像文件\n",
    "    - 一个图像文件名的列表，在这种情况下开发者可以通过load_images参数控制选择将文件图像一次性加载到内存中\n",
    "    - 一个表示图像的numpy数组列表，注意这种情况不支持遮罩\n",
    "- fps：每秒读入的图像帧数，该参数可以通过设定durations来替代\n",
    "- durations：每个图像在剪辑中显示的时长列表，因此可以给每个图像不同的播放时间，如果设置了fps，该参数将不起作用\n",
    "- with_mask：是否将PNG图像的alpha层作为遮罩\n",
    "- ismask：是否将生成剪辑作为遮罩\n",
    "- load_images：是否在处理前集中将图像文件加载到内存，如果为True，则对于sequence对应图像文件的情况，一次性的将所有图像文件先加载到内存，否则每处理一个文件加载一个。该参数仅对sequence为文件名列表的情况生效。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9591b022",
   "metadata": {},
   "source": [
    "# VideoClip的子类\n",
    "## DataVideoClip\n",
    "DataVideoClip是VideoClip的直接子类，它的视频剪辑的连续帧都是从一系列数据集经过函数处理生成的，DataVideoClip类只有构造方法，没有独有属性和其他方法，因此DataVideoClip其实就是通过数据集经函数处理构造的视频剪辑。\n",
    "\n",
    "构造方法如下：\n",
    "__init__(self, data, data_to_frame, fps, ismask=False, has_constant_size=True)\n",
    "\n",
    "说明：\n",
    "- data：用于生成视频剪辑的原始数据集列表\n",
    "- data_to_frame：用于对数据进行处理的函数，带一个参数为生成一个帧的原始数据，data_to_frame对该数据进行处理后生成帧数据\n",
    "- fps：生成剪辑的帧率\n",
    "- has_constant_size：与父类的has_constant_size参数相同\n",
    "实际上处理时，是将剪辑t时刻的帧取data[int(fps*t)]中的数据进行处理。\n",
    "\n",
    "---\n",
    "\n",
    "## UpdatedVideoClip\n",
    "\n",
    "构造方法语法如下：\n",
    "__init__(self, world, ismask=False, duration=None)\n",
    "\n",
    "说明：\n",
    "- UpdatedVideoClip的构造方法是个闭包，其内定义了用于构造帧的嵌套函数make_frame\n",
    "- 参数world是一个有特殊要求的对象，该对象必须有一个属性clip_t、两个方法update和to_frame：\n",
    "world.clip_t ：与world状态对应的剪辑时间\n",
    "world.update（）方法：更新world的状态（包括增加clip_t一个时间步）的方法\n",
    "world.to_frame()方法：根据world的状态生成一个帧的方法\n",
    "- ismask：如果生成的剪辑是值为0-1 WxH遮罩则为True\n",
    "- duration：剪辑的时长，单位是秒\n",
    "\n",
    "对应剪辑生成t时刻的帧时，如果world的clip_t 小于t，则会循环执行world.update方法，直到clip_t 大于等于t，此时再调用world.to_frame()输出帧。\n",
    "\n",
    "UpdatedVideoClip的帧数据依赖于world对象状态变更，该类在科学研究中有特殊用途，对于那些在生成帧数据前需要使用算法执行一些步骤进行处理时特别有用。\n",
    "\n",
    "---\n",
    "\n",
    "## ImageClip\n",
    "ImageClip是VideoClip的直接子类，用于生成固定不变的视频剪辑。ImageClip是从一个图像文件或内存中图像数组数据生成的视频剪辑，对应视频任何时候都是显示该图像。\n",
    "- img：任何图像文件或代表一个RGB图像的数组（例如一个视频剪辑的帧数据）\n",
    "- ismask：剪辑是否为遮罩，如果要构建遮罩剪辑需要设置为True\n",
    "- transparent：如果希望图片的alpha层（如果存在）用作构建剪辑的遮罩，此参数应设置为True,此时图像的背景层作为视频剪辑，图片的alpha层作为剪辑的遮罩剪辑\n",
    "- fromalpha：如果只是将图片的alpha层构建剪辑，则fromalpha应设置为True\n",
    "\n",
    "---\n",
    "\n",
    "## ColorClip\n",
    "ColorClip是仅显示同一种颜色的剪辑。\n",
    "\n",
    "调用语法：\n",
    "__init__(self, size, color=None, ismask=False, duration=None, col=None)\n",
    "参数说明：\n",
    "- size：剪辑的大小，一个宽和高组成的元组\n",
    "- color：如果ismask为False，则为一个RGB的三元组（缺省为黑色全0），如果ismask为True，则color代表灰度值，为一个0到1之间的浮点数\n",
    "- ismask：是否将剪辑作为遮罩\n",
    " duration：剪辑时长\n",
    "\n",
    "---\n",
    "\n",
    "## TextClip\n",
    "用于生成文本剪辑，对应剪辑内容来自于指定文本或文本文件，TextClip是ImageClip的直接子类。在具体处理时，TextClip先调用ImageMagick将文本转换成一个png图片，再调用ImageClip的构造方法将该图片构造成剪辑，因此使用TextClip前需要先下载并安装ImageMagick应用\n",
    "\n",
    "构造方法参数说明：\n",
    "- txt：需要在剪辑中显示的文字，这个参数和参数filename可以相互替换，二者同时存在时txt优先\n",
    "- filename：存储需要在剪辑中显示文字的文件名\n",
    "- size：剪辑的大小，如果method参数为’label’可以设置为None，由moviepy自动根据文字设定，但如果method参数为’caption’，则必须设置，此时高度也可以设置为None，由moviepy根据文字数量、大小以及宽度自动设置\n",
    "- color：文字显示的前景色，请参考下面介绍list方法时的说明\n",
    "- bg_color：剪辑的背景色\n",
    "- fontsize：文字字体大小\n",
    "- font：字体设置，字体和运行机器相关，在机器上能使用的字体请参考下面介绍list方法时的说明\n",
    "- stroke_color：文字轮廓线的颜色，如果为None则没有轮廓线\n",
    "- stroke_width：轮廓线的宽度，可以为浮点数\n",
    "- method：可以设置为’label’或’caption’，设置为’label’时，图片将自动调整大小以适合剪辑的大小，这是该参数的缺省值。设置为’caption’时，文字将在size参数指定范围内显示，此时文字会自动换行，但自动换行功能由于使用的ImageMagick库的问题有时不能正确工作\n",
    "- kerning：更改字母之间的默认间距。例如kerning=-1与默认间距相比，将使字母之间的间距更接近1个像素\n",
    "- align：文字的对齐方式，仅在method设置为caption时生效，默认值为center，可选择的值包括：center 、 East 、 West 、 South 、 North\n",
    "- transparent：如果要考虑图像的透明度需要设置为True，这也是缺省值\n",
    "- remove_temp：是否删除临时文件\n",
    "\n",
    "## list方法\n",
    "list方法用于返回TextClip构造方法中font和color参数在执行机器上可以使用的相关取值列表。\n",
    "\n",
    "调用语法为：\n",
    "list(arg)\n",
    "\n",
    "其中参数arg只有两个取值‘font’和‘color’，注意该方法是一个静态方法，直接带类名就可以调用。\n",
    "\n",
    "注意：\n",
    "由于moviepy对多语言环境支持存在一些问题，因此在执行TextClip.list(‘font’)会报错，报错信息为：`UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb7 in position 8: invalid s`\n",
    "在这种情况下，要支持中文环境，需要修改VideoClip的1177行，具体修改内容如下：\n",
    "```python\n",
    "if arg == 'font':\n",
    "    #return [l.decode('UTF-8')[8:] for l in lines if l.startswith(b\"  Font:\")]\n",
    "    return [l.decode('ANSI')[8:] for l in lines if l.startswith(b\"  Font:\")]\n",
    "```\n",
    "\n",
    "## search方法\n",
    "该方法是作为list方法的一个补充使用，因为list ‘font’和‘color’后，这两个类型一般取值都很多，因此输出会很多内容，不方便查看，而search除了指定参数名外，还可以对参数可取值进行过滤。实际上search实现时，也是先执行list方法，将list方法的结果再进行一次过滤再输出。\n",
    "\n",
    "调用语法：\n",
    "search(string, arg)\n",
    "其中参数arg与list中的arg一样，而string是过滤条件的字符串，该字符串不区分大小写，最终结果只显示参数可取值中包含了string字符串内容的可取值。\n",
    "\n",
    "---\n",
    "\n",
    "## VideoFileClip视频文件剪辑\n",
    "VideoFileClip类是VideoClip的直接子类，是从一个视频文件创建一个剪辑类，除了从父类继承的特性和方法外，VideoFileClip实现了自己的构造方法和close方法，另外VideoFileClip有1个自己独的属性filename，与读取视频文件给的名字完全一致。VideoFileClip加载视频文件时，可以调整剪辑对应分辨率大小，可以根据应用要求设定是否加载音频。VideoFileClip加载视频文件时，会调用FFMPEG_VideoReader来加载视频文件，加载时会对视频文件进行加锁处理。\n",
    "\n",
    "参数说明：\n",
    "- filename：视频文件名，可以带路径\n",
    "- has_mask：是否有遮罩 ，如果视频文件带遮罩，则设置has_mask为True。视频文件一般很少带遮罩，但有些视频编码支持遮罩功能。\n",
    "- audio：如果视频文件不带音频或者不希望加载视频文件的音频，可以将audio参数设置为False\n",
    "- audio_buffersize：音频文件读取缓冲区大小，字节为单位，一般用缺省值足够，如果audio_buffersize比一个音频帧的大小还要小，会自动使用音频帧的大小代替\n",
    "- target_resolution：设置为加载后需要变换到的分辨率，类型为列表或元组，第一个元素为分辨率的高，第二个为宽，如果高或宽有一个为None，则保持现有纵横比调整帧的大小。如果保持原分辨率不变，则不需要设置本参数或设置为None。如果设置了新的分辨率，则在调用ffmpeg 返回视频剪辑的帧之前会按新的分辨率调整帧的大小。这比使用转换为高分辨率流然后再调整分辨率会快很多\n",
    "- resize_algorithm：要改变加载后的视频分辨率，可以通过resize_algorithm指定调整分辨率的算法，缺省值为 “bicubic”，还可以是 “bilinear” 、\"fast_bilinear\"等。关于算法的更多信息请参考：https://ffmpeg.org/ffmpeg-scaler.html\n",
    " audio_fps：声音的采样频率\n",
    " audio_nbytes：声音采样的位数\n",
    " verbose：是否在标准输出设备上显示处理信息\n",
    " fps_source：从视频的元数据metadata哪个数据中获取fps值，默认设置为’tbr’，但可以设置为’fps’，这可能有助于导入慢动作视频，否则可能会出意外。\n",
    "\n",
    "close()\n",
    "构造方法会对视频文件进行加锁，并占用相关资源，如果要释放文件和资源，需要调用close方法或等加载处理的进程结束。close方法除了self无其他参数，其目的就是释放文件和其他占用的资源。\n",
    "\n",
    "需要注意，如果一个VideoFileClip实例被浅拷贝到另一个对象，这两个对象中任意一个调用close方法都可能会释放文件导致另一个实例的close方法失败。具体情况与代码的上下文环境相关。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "81a347f2-0dd4-42a3-9107-adc4cc22d072",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Writing frames test_ims/frame%03d.png.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                          "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done writing frames test_ims/frame%03d.png.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "# from IPython.display import HTML\n",
    "# HTML('<video src=\"./V202201092356.mp4\" width=500 type=\"video/mp4\" controls></video> ')\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc-autonumbering": false
 },
 "nbformat": 4,
 "nbformat_minor": 5
}